// components/datika/datika.js
Component({
  /**
   * 组件的属性列表
   */
  properties: {
    show: Boolean, // 控制弹窗显示/隐藏
    singleChoiceQuestions: Array, // 单选题列表（类型0）
    multipleChoiceQuestions: Array, // 多选题列表（类型1）
    fillBlankQuestions: Array, // 填空题列表（类型2）
    trueFalseQuestions: Array, // 判断题列表（类型3）
    essayQuestions: Array, // 问答题列表（类型4）
    termExplanationQuestions: Array, // 名词解释题列表（类型5）
    discussionQuestions: Array, // 论述题列表（类型6）
    answerCardDetail: Object, // 答题卡详情数据
    answerRecords: Array // 答题记录列表
  },

  /**
   * 组件的初始数据
   */
  data: {
    showtan: false,
    showModal: false, // 控制弹窗显示的内部状态
    animation: {}, // 弹窗动画
    currentQuestionType: 'all', // 当前显示的题型：all（全部）、single（单选）、multiple（多选）、fillBlank（填空）、trueFalse（判断）、essay（问答）、termExplanation（名词解释）、discussion（论述）
    completedQuestions: [], // 已完成的题目列表，格式如：['single_1', 'multiple_3']
    totalQuestions: 0, // 总题目数
    answeredCount: 0, // 已答题目数
    questionStatus: {}, // 题目状态映射，格式如：{questionId: 'answered'/'unanswered'}
    questionTypeNames: {
      'all': '全部题目',
      'single': '单选题',
      'multiple': '多选题',
      'fillBlank': '填空题',
      'trueFalse': '判断题',
      'essay': '问答题',
      'termExplanation': '名词解释题',
      'discussion': '论述题'
    }
  },

  /**
   * 监听属性变化
   */
  observers: {
    'show': function (newShow) {
      if (newShow) {
        // 确保正确设置内部显示状态并执行打开动画
        this.setData({ showModal: true });
        // 立即执行打开动画，不延迟
        if (!this.animation) {
          this.initAnimation();
        }
        // 先设置到下方
        this.animation.translateY(900).step();
        this.setData({ animation: this.animation.export() });
        // 然后回到原位
        setTimeout(() => {
          this.animation.translateY(0).step();
          this.setData({ animation: this.animation.export() });
        }, 10);
      } else {
        // 只有当外部show为false时才关闭弹窗
        if (this.data.showModal) {
          this.closeModal();
        }
      }
    },
    'answerCardDetail': function (newDetail) {
      if (newDetail) {
        this.updateAnswerCardStatus(newDetail);
      }
    },
    'answerRecords': function (newRecords) {
      if (newRecords) {
        this.updateAnswerRecordsStatus(newRecords);
      }
    }
  },

  /**
   * 组件的方法列表
   */
  methods: {
    // 初始化动画
    initAnimation: function () {
      this.animation = wx.createAnimation({
        duration: 300,
        timingFunction: 'ease',
      });
    },

    // 打开弹窗
    openModal: function () {
      // 确保动画已初始化
      if (!this.animation) {
        this.initAnimation();
      }

      // 添加弹出动画
      this.animation.translateY(500).step();
      this.setData({
        animation: this.animation.export()
      });

      // 然后回到原位，形成从下往上弹出的效果
      setTimeout(() => {
        this.animation.translateY(0).step();
        this.setData({
          animation: this.animation.export()
        });
      }, 10);
    },

    // 关闭弹窗
    closeModal: function () {
      // 确保动画已初始化
      if (!this.animation) {
        this.initAnimation();
      }

      // 执行关闭动画
      this.animation.translateY(1000).step();
      this.setData({
        animation: this.animation.export()
      });

      // 动画结束后隐藏弹窗并通知父组件
      setTimeout(() => {
        // 先设置内部状态为隐藏
        this.setData({ showModal: false });
        // 然后触发关闭事件通知父组件更新外部状态
        this.triggerEvent('close');
      }, 300);
    },

    // 切换题型显示
    switchQuestionType: function (e) {
      const type = e.currentTarget.dataset.type;
      this.setData({
        currentQuestionType: type
      });
    },

    // 跳转到指定题目
    goToQuestion: function (e) {
      // 从dataset中获取题目ID和类型
      const { questionId, type } = e.currentTarget.dataset;

      // 检查questionId是否有效
      if (!questionId || questionId === 'undefined' || questionId === 'null') {
        wx.showToast({
          title: '题目ID无效',
          icon: 'none'
        });
        return;
      }

      // 标记当前题目为已完成状态
      this.setData({
        [`questionStatus.${questionId}`]: 'answered'
      });
      console.log(this.data.answerRecords)
      console.log(questionId)
      // 触发父组件的跳转事件
      this.triggerEvent('goti', {
        questionId: questionId,
      });

      // 关闭答题卡弹窗
      this.closeModal();
    },

    // 检查题目是否已完成
    isQuestionCompleted: function (type, number) {
      const questionKey = `${type}_${number}`;
      return this.data.completedQuestions.includes(questionKey);
    },

    // 更新答题卡状态
    updateAnswerCardStatus: function (answerCardDetail) {
      if (!answerCardDetail) return;

      // 直接从answerCardDetail对象获取数据，不再嵌套一层
      const total_questions = answerCardDetail.total_questions || 0;
      const answered_questions = answerCardDetail.answered_questions || 0;

      this.setData({
        totalQuestions: total_questions,
        answeredCount: answered_questions
      });
    },

    // 更新答题记录状态
    updateAnswerRecordsStatus: function (answerRecords) {
      if (!answerRecords || !Array.isArray(answerRecords)) {
        return;
      }

      const questionStatus = {};
      const completedQuestions = [];
      const singleChoiceQuestions = [];
      const multipleChoiceQuestions = [];
      const fillBlankQuestions = [];
      const trueFalseQuestions = [];
      const essayQuestions = [];
      const termExplanationQuestions = [];
      const discussionQuestions = [];

      // 处理答题记录，标记已答题目的状态
      answerRecords.forEach((record, index) => {
        // 使用question_id作为主要标识，如果不存在则使用id
        const questionId = record.question_id || record.id;

        if (questionId) {
          // 标记题目状态 - 确保能正确识别各种类型的答案
          const hasUserAnswer = record.user_answer !== null && record.user_answer !== undefined && record.user_answer !== '';
          questionStatus[questionId] = hasUserAnswer ? 'answered' : 'unanswered';

          // 根据题目类型和序号添加到已完成列表
          const questionKey = `question_${questionId}`;
          if (hasUserAnswer && !completedQuestions.includes(questionKey)) {
            completedQuestions.push(questionKey);
          }

          // 根据题目类型分类
          const questionData = {
            id: questionId,
            isCorrect: record.isCorrect,
            question_number: index + 1,
            question_title: record.question_title || '',
            question_type: record.question_type || 0
          };

          // 根据题目类型进行精确分类
          switch (record.question_type) {
            case 0: // 单选题
              singleChoiceQuestions.push(questionData);
              break;
            case 1: // 多选题
              multipleChoiceQuestions.push(questionData);
              break;
            case 2: // 填空题
              fillBlankQuestions.push(questionData);
              break;
            case 3: // 判断题
              trueFalseQuestions.push(questionData);
              break;
            case 5: // 名词解释题
              termExplanationQuestions.push(questionData);
              break;
            case 4: // 问答题
              essayQuestions.push(questionData);
              break;
            case 6: // 论述题
              discussionQuestions.push(questionData);
              break;
            default: // 默认作为单选题处理
              singleChoiceQuestions.push(questionData);
          }
        }
      });

      this.setData({
        questionStatus,
        completedQuestions,
        singleChoiceQuestions: singleChoiceQuestions,
        multipleChoiceQuestions,
        fillBlankQuestions,
        trueFalseQuestions,
        essayQuestions,
        termExplanationQuestions,
        discussionQuestions
      });
      console.log(this.data.singleChoiceQuestions)
    },

    // 获取题目状态
    getQuestionStatus: function (questionId) {
      return this.data.questionStatus[questionId] || 'unanswered';
    },

    // 检查题目是否已答
    isQuestionAnswered: function (questionId) {
      return this.getQuestionStatus(questionId) === 'answered';
    },

    clearthis: function () {
      this.setData({
        types: "",
        showtan: false,
        tishititle: "",
        tishimessage: "",
      })
    },
    queren: function () {
      // 用户确认重做，触发父组件的事件
      this.triggerEvent('redoAnswerCard');
      // 关闭答题卡弹窗
      this.closeModal();
    },
    // 确认重做整张答题卡
    confirmRedoAnswerCard: function () {
      // 检查是否有已答题目
      if (this.data.answeredCount === 0) {
        wx.showToast({
          title: '当前没有已答题目',
          icon: 'none'
        });
        return;
      }
      this.setData({
        types: "重做科目",
        showtan: true,
        tishititle: "已加入错题集",
        tishimessage: `确定要重做整张答题卡吗？`,
        // 这将清除您已答的${ this.data.answeredCount }道题目。?
      })


      // // 显示确认对话框
      // wx.showModal({
      //   title: '确认重做',
      //   content: `确定要重做整张答题卡吗？这将清除您已答的${this.data.answeredCount}道题目。`,
      //   confirmText: '确定',
      //   cancelText: '取消',
      //   success: (res) => {
      //     if (res.confirm) {

      //     }
      //   }
      // });
    }
  },

  /**
   * 组件生命周期
   */
  lifetimes: {
    attached: function () {
      // 组件挂载时初始化动画
      this.initAnimation();
    }
  }
});